// map.js


/**
 * 获取导航路线
 * startPoint - 起点
 * endPoint - 终点
 * {Promise<{ routes: Array<{ points: Array<{ longitude: number, latitude: number }>, light: string, time: string, detail: string }> }>}
 */

// api/map.js
export const getNavigationRoutes = async (startPoint, endPoint) => {
  try {
    // 将起点和终点转换为字符串形式的经纬度
    const originStr = `${startPoint.longitude},${startPoint.latitude}`;
    const destinationStr = `${endPoint.longitude},${endPoint.latitude}`;

    const response = await uni.request({
      url: 'http://localhost:8004/api/v2/att/map/path', // 后端 API 路径
      method: 'POST', // 使用 POST 请求
      header: {
        'Content-Type': 'application/json' // 设置请求头为 JSON
      },
      data: JSON.stringify({
        origen: originStr, // 修正字段名并转换为字符串
        destination: destinationStr, // 转换为字符串
        strategy: 'default' // 添加 strategy 字段
      })
    });

    if (response.statusCode === 200) {
      const { way1, points1, distance1, duration1, way2, points2, distance2, duration2, way3, points3, distance3, duration3 } = response.data;
      console.log('后端返回的数据:', response.data);

      // 检查经纬度值的合法性
      const validatePoints = (points) => {
        if (!points) return []; // 如果points为null，返回空数组
        
        return points.map(point => {
          const lat = parseFloat(point.latitude);  // 纬度
          const lng = parseFloat(point.longitude); // 经度

          // 检查纬度是否合法
          if (isNaN(lat) || lat < -90 || lat > 90) {
            console.warn('非法纬度值:', lat, '原始点:', point);
          }

          // 检查经度是否合法
          if (isNaN(lng) || lng < -180 || lng > 180) {
            console.warn('非法经度值:', lng, '原始点:', point);
          }

          return {
            longitude: lng,
            latitude: lat
          };
        });
      };

      // 格式化时间，将分钟转换为"小时分钟"格式
      const formatTime = (minutes) => {
        if (!minutes) return "未知"; // 如果时间为null，返回未知
        
        if (minutes < 60) {
          return `${minutes}分钟`; // 不足60分钟，直接显示分钟
        } else {
          const hours = Math.floor(minutes / 60); // 计算小时数
          const mins = minutes % 60; // 计算剩余分钟数
          return `${hours}小时${mins}分钟`; // 格式化显示
        }
      };
      
      // 格式化距离
      const formatDistance = (meters) => {
        if (!meters) return "未知距离"; // 如果距离为null，返回未知距离
        
        return `约${Math.floor(parseInt(meters) / 1000)}公里`;
      };

      // 判断是否有可用路线
      const hasValidRoutes = way1 || way2 || way3;
      
      if (!hasValidRoutes) {
        console.warn('没有可用的路线，距离可能过远，创建直线路线');
        
        // 计算起点和终点的直线距离（使用简化的平面距离计算）
        const calculateDistance = (start, end) => {
          const R = 6371; // 地球半径，单位公里
          const dLat = (end.latitude - start.latitude) * Math.PI / 180;
          const dLon = (end.longitude - start.longitude) * Math.PI / 180;
          const a = 
            Math.sin(dLat/2) * Math.sin(dLat/2) +
            Math.cos(start.latitude * Math.PI / 180) * Math.cos(end.latitude * Math.PI / 180) * 
            Math.sin(dLon/2) * Math.sin(dLon/2);
          const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
          return R * c;
        };
        
        const distance = calculateDistance(startPoint, endPoint) * 1000; // 转换为米
        const estimatedDuration = (distance / 1.4) / 60; // 按1.4米/秒的步行速度计算分钟数
        
        // 创建一个直线路线
        return {
          routes: [
            {
              way: "步行",
              polylines: [
                {
                  points: [
                    { longitude: startPoint.longitude, latitude: startPoint.latitude },
                    { longitude: endPoint.longitude, latitude: endPoint.latitude }
                  ],
                  color: '#007AFF',
                  width: 4,
                  dottedLine: false
                }
              ],
              light: `路灯未知`,
              time: formatTime(Math.floor(estimatedDuration)),
              detail: `步行${formatDistance(distance)}`,
              isActive: true,
              isDirectLine: true, // 标记为直线路线
              distanceText: formatDistance(distance)
            }
          ]
        };
      }

      // 处理数据
      const routes = [];
      
      // 添加路线1（如果存在）
      if (way1 && points1) {
        routes.push({
          way: way1,
          polylines: [
            {
              points: validatePoints(points1), // 使用验证后的点集
              color: '#007AFF',
              width: 4,
              dottedLine: false
            }
          ],
          light: `路灯100%`,
          time: formatTime(Math.floor(parseInt(duration1) / 60)), // 格式化时间
          detail: `步行${formatDistance(distance1)}`,
          isActive: true,
          distanceText: formatDistance(distance1)
        });
      }
      
      // 添加路线2（如果存在）
      if (way2 && points2) {
        routes.push({
          way: way2,
          polylines: [
            {
              points: validatePoints(points2), // 使用验证后的点集
              color: '#FF0000',
              width: 4,
              dottedLine: false
            }
          ],
          light: `路灯80%`,
          time: formatTime(Math.floor(parseInt(duration2) / 60)), // 格式化时间
          detail: `驾车${formatDistance(distance2)}`,
          isActive: routes.length === 0, // 如果没有路线1，则此路线为活动状态
          distanceText: formatDistance(distance2)
        });
      }
      
      // 添加路线3（如果存在）
      if (way3 && points3) {
        routes.push({
          way: way3,
          polylines: [
            {
              points: validatePoints(points3), // 使用验证后的点集
              color: '#00FF00',
              width: 4,
              dottedLine: false
            }
          ],
          light: `路灯90%`,
          time: formatTime(Math.floor(parseInt(duration3) / 60)), // 格式化时间
          detail: `驾车${formatDistance(distance3)}`,
          isActive: routes.length === 0, // 如果没有其他路线，则此路线为活动状态
          distanceText: formatDistance(distance3)
        });
      }
      
      // 如果没有有效路线，添加一条直线路线
      if (routes.length === 0) {
        const distance = calculateDistance(startPoint, endPoint) * 1000; // 转换为米
        const estimatedDuration = (distance / 1.4) / 60; // 按1.4米/秒的步行速度计算分钟数
        
        routes.push({
          way: "步行",
          polylines: [
            {
              points: [
                { longitude: startPoint.longitude, latitude: startPoint.latitude },
                { longitude: endPoint.longitude, latitude: endPoint.latitude }
              ],
              color: '#007AFF',
              width: 4,
              dottedLine: true // 使用虚线表示这是估计路线
            }
          ],
          light: `路灯未知`,
          time: formatTime(Math.floor(estimatedDuration)),
          detail: `步行${formatDistance(distance)}`,
          isActive: true,
          isDirectLine: true, // 标记为直线路线
          distanceText: formatDistance(distance)
        });
      }

      return { routes };
    } else {
      throw new Error('请求失败');
    }
  } catch (error) {
    console.error('API 请求错误:', error);
    // 出错时返回直线路线
    const calculateDistance = (start, end) => {
      const R = 6371; // 地球半径，单位公里
      const dLat = (end.latitude - start.latitude) * Math.PI / 180;
      const dLon = (end.longitude - start.longitude) * Math.PI / 180;
      const a = 
        Math.sin(dLat/2) * Math.sin(dLat/2) +
        Math.cos(start.latitude * Math.PI / 180) * Math.cos(end.latitude * Math.PI / 180) * 
        Math.sin(dLon/2) * Math.sin(dLon/2);
      const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
      return R * c;
    };
    
    const distance = calculateDistance(startPoint, endPoint) * 1000; // 转换为米
    const estimatedDuration = (distance / 1.4) / 60; // 按1.4米/秒的步行速度计算分钟数
    
    return {
      routes: [
        {
          way: "步行",
          polylines: [
            {
              points: [
                { longitude: startPoint.longitude, latitude: startPoint.latitude },
                { longitude: endPoint.longitude, latitude: endPoint.latitude }
              ],
              color: '#007AFF',
              width: 4,
              dottedLine: true
            }
          ],
          light: `路灯未知`,
          time: `约${Math.floor(estimatedDuration)}分钟`,
          detail: `步行约${Math.floor(distance / 1000)}公里`,
          isActive: true,
          isDirectLine: true, // 标记为直线路线
          isError: true, // 标记为错误请求
          distanceText: `约${Math.floor(distance / 1000)}公里`
        }
      ]
    };
  }
};

/**
 * 地址转换为经纬度坐标
 * @param {string} address - 地址文本
 * @returns {Promise<{longitude: number, latitude: number}>} - 返回经纬度坐标
 */
export const getGeocode = async (address) => {
  try {
    // 处理参数，确保地址文本有效
    if (!address || typeof address !== 'string') {
      throw new Error('地址文本无效');
    }
    
    // // 如果地址已经包含经纬度信息（格式：xxx 纬度,经度），直接提取
    // const coordsMatch = address.match(/(\d+\.\d+),(\d+\.\d+)$/);
    // if (coordsMatch) {
    //   const [_, latitude, longitude] = coordsMatch;
    //   return {
    //     longitude: parseFloat(longitude),
    //     latitude: parseFloat(latitude)
    //   };
    // }
    
    // 调用后端API获取经纬度
    const response = await uni.request({
      url: 'http://localhost:8004/api/v2/att/map/geocode',
      method: 'GET',
      data: {
        address: address
      }
    });
    
    // 处理响应
    if (response.statusCode === 200 && response.data.code === 0) {
      // 成功获取经纬度
      const locationStr = response.data.data;
      
      // 高德地图API返回的经纬度格式为"经度,纬度"
      const [longitude, latitude] = locationStr.split(',').map(Number);
      
      console.log('地址转换为经纬度成功:', { address, longitude, latitude });
      
      return {
        longitude,
        latitude
      };
    } else {
      // 获取经纬度失败
      console.error('获取经纬度失败:', response.data);
      throw new Error(response.data.msg || '获取经纬度失败');
    }
  } catch (error) {
    console.error('地址转换经纬度出错:', error);
    throw error;
  }
};







/* 模拟数据
const mockData = {
  routes: [
    {
      points: [
        { longitude: 120.123, latitude: 30.456 },
        { longitude: 120.234, latitude: 30.567 },
        { longitude: 120.345, latitude: 30.678 }
      ],
      light: "80",
      time: "30分钟",
      detail: "方案一：步行距离最短"
    },
    {
      points: [
        { longitude: 120.123, latitude: 30.456 },
        { longitude: 120.456, latitude: 30.789 },
        { longitude: 120.567, latitude: 30.890 }
      ],
      light: "60",
      time: "35分钟",
      detail: "方案二：经过公园"
    },
    {
      points: [
        { longitude: 120.123, latitude: 30.456 },
        { longitude: 120.678, latitude: 30.901 },
        { longitude: 120.789, latitude: 31.012 }
      ],
      light: "90",
      time: "40分钟",
      detail: "方案三：景色最佳"
    }
  ]
};


 * 获取导航路线
 * @param {string} startPoint - 起点
 * @param {string} endPoint - 终点
 * @returns {Promise<{ routes: Array<{ points: Array<{ longitude: number, latitude: number }>, light: string, time: string, detail: string }> }>}
 
export const getNavigationRoutes = async (startPoint, endPoint) => {
  return new Promise((resolve) => {
    // 模拟延迟 1 秒，模拟网络请求
    setTimeout(() => {
      resolve(mockData);
    }, 1000);
  });
};
*/